home *** CD-ROM | disk | FTP | other *** search
/ Otherware / Otherware_1_SB_Development.iso / mac / util / multifin / sasleep.sit / Sound Asleep ƒ / Sound Asleep Source / soundasleep.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-06-19  |  6.5 KB  |  262 lines
  1. /*
  2.     Sound Asleep
  3.     ⌐1992 David Thompson
  4.     
  5.     A little hack to audibly let the user know when the PowerBook is either going
  6.     to sleep or waking up.
  7.     
  8.     This source was hacked out of the Sample.c program that comes with MPW.
  9.     There is also an assembler portion to this code. This source is free by the way!
  10. */
  11.  
  12. /*    You don't need all of these #includes. I just put them in to get going faster. */
  13. #include    <Values.h>
  14. #include    <Types.h>
  15. #include    <Resources.h>
  16. #include    <QuickDraw.h>
  17. #include    <Fonts.h>
  18. #include    <Events.h>
  19. #include    <Windows.h>
  20. #include    <Menus.h>
  21. #include    <TextEdit.h>
  22. #include    <Dialogs.h>
  23. #include    <Desk.h>
  24. #include    <ToolUtils.h>
  25. #include    <Memory.h>
  26. #include    <SegLoad.h>
  27. #include    <Files.h>
  28. #include    <OSUtils.h>
  29. #include    <OSEvents.h>
  30. #include    <DiskInit.h>
  31. #include    <Packages.h>
  32. #include    <Traps.h>
  33. #include    <Power.h>
  34. #include    <GestaltEqu.h>
  35. #include    <Sound.h>
  36.  
  37. #pragma segment Main
  38.  
  39. /* C prototypes */
  40. Boolean DoEvent(EventRecord *event);
  41. Boolean DoMenuCommand(long menuResult);
  42. Boolean Initialize(void);
  43.  
  44. /* Assembler routine declarations */
  45. extern pascal void soundHandleSetup(Handle yawnHandle, Handle wakeHandle);
  46. extern pascal long soundasleep();
  47. extern void _DataInit();
  48.  
  49. /* Some defines */
  50. #define    rMenuBar                128        /* application's menu bar */
  51. #define    rAboutAlert                128        /* about alert */
  52.  
  53. #define    mApple                    128        /* Apple menu */
  54. #define    iAbout                    1
  55.  
  56. #define    mFile                    129        /* File menu */
  57. #define    iQuit                    1
  58.  
  59. #define    mEdit                    130        /* Edit menu */
  60.  
  61. /* Some globals */
  62. SleepQRec    myRec;
  63. Handle    yawnHndl = nil, wakeHndl = nil;
  64.  
  65. main()
  66. {
  67.     EventRecord    event;
  68.     Boolean    keepgoing = false;
  69.  
  70.     UnloadSeg((Ptr) _DataInit);        /* note that _DataInit must not be in Main! */
  71.     
  72.     MaxApplZone();                    /* expand the heap so code segments load at the top */
  73.  
  74.     keepgoing = Initialize();        /* initialize the program */
  75.     UnloadSeg((Ptr) Initialize);    /* note that Initialize must not be in Main! */
  76.  
  77.     while (keepgoing)
  78.     {
  79.         SystemTask();
  80.         if (GetNextEvent(everyEvent, &event))
  81.         {
  82.             keepgoing = DoEvent(&event);
  83.         }
  84.     }
  85.     ExitToShell();
  86. }
  87.  
  88.  
  89. /*    Do the right thing for an event. Determine what kind of event it is, and call
  90.     the appropriate routines.
  91.     We only really care about menu events.
  92. */
  93.  
  94. Boolean DoEvent(event)
  95. EventRecord    *event;
  96. {
  97.     WindowPtr    window;
  98.     char        key;
  99.     Boolean        keepgoing;
  100.  
  101.     switch (event->what)
  102.     {
  103.         case mouseDown:
  104.             if (FindWindow(event->where, &window) == inMenuBar)
  105.             {
  106.                 keepgoing = DoMenuCommand(MenuSelect(event->where));
  107.             }
  108.             break;
  109.         case keyDown:
  110.         case autoKey:                        /* check for menukey equivalents */
  111.             key = event->message & charCodeMask;
  112.             if (event->modifiers & cmdKey)            /* Command key down */
  113.             {
  114.                 if (event->what == keyDown)
  115.                 {
  116.                     keepgoing = DoMenuCommand(MenuKey(key));
  117.                 }
  118.             }
  119.             break;
  120.         default:
  121.             keepgoing = true;
  122.             break;
  123.     }
  124.     return keepgoing;
  125. } /*DoEvent*/
  126.  
  127.  
  128. Boolean DoMenuCommand(menuResult)
  129. long        menuResult;
  130. {
  131.     short        menuID;                /* the resource ID of the selected menu */
  132.     short        menuItem;            /* the item number of the selected menu */
  133.     short        itemHit;
  134.     Str255        daName;
  135.     short        daRefNum;
  136.     Boolean        handledByDA;
  137.     Boolean        keepgoing = true;
  138.  
  139.     menuID = HiWord(menuResult);    /* use macros for efficiency to... */
  140.     menuItem = LoWord(menuResult);    /* get menu item number and menu number */
  141.     switch ( menuID ) {
  142.         case mApple:
  143.             switch ( menuItem ) {
  144.                 case iAbout:        /* bring up alert for About */
  145.                     itemHit = Alert(rAboutAlert, nil);
  146.                     break;
  147.                 default:            /* all non-About items in this menu are DAs */
  148.                     /* type Str255 is an array in MPW 3 */
  149.                     GetItem(GetMHandle(mApple), menuItem, daName);
  150.                     daRefNum = OpenDeskAcc(daName);
  151.                     break;
  152.             }
  153.             break;
  154.         case mFile:
  155.             switch ( menuItem ) {
  156.                 case iQuit:
  157.                     SleepQRemove(&myRec);
  158.                     keepgoing = false;
  159.                     break;
  160.             }
  161.             break;
  162.         case mEdit:                    /* call SystemEdit for DA editing & MultiFinder */
  163.             handledByDA = SystemEdit(menuItem-1);    /* since we don╒t do any Editing */
  164.             break;
  165.     }
  166.     HiliteMenu(0);                    /* unhighlight what MenuSelect (or MenuKey) hilited */
  167.     return keepgoing;
  168. } /*DoMenuCommand*/
  169.  
  170. /*    Set up the world.
  171.     Make sure we're running on a PowerBook or MacPortable on a System that has Gestalt.
  172.     Set up the menus so the user can Quit when he wants to.
  173.     We put this in it's own segment so we can unload it afterwards. */
  174. #pragma segment Initialize
  175. Boolean Initialize()
  176. {
  177.     InitGraf((Ptr) &qd.thePort);
  178.     InitFonts();
  179.     InitWindows();
  180.     InitMenus();
  181.     TEInit();
  182.     InitDialogs(nil);
  183.     InitCursor();
  184.  
  185.     if (NGetTrapAddress(_GestaltDispatch, ToolTrap) != GetTrapAddress(_Unimplemented))
  186.     {
  187.         long    machineType;
  188.  
  189.         if (!Gestalt(gestaltMachineType, &machineType))
  190.         {
  191.             if (machineType == gestaltPortable ||
  192.                 machineType > gestaltMacLC)            // PowerBooks (and Quadras (need to fix this))
  193.             {
  194.                 Handle        menuBar;
  195.             
  196.                 /* Set up the menu bar */
  197.                 menuBar = GetNewMBar(rMenuBar);            /* read menus into menu bar */
  198.                 SetMenuBar(menuBar);                    /* install menus */
  199.                 DisposHandle(menuBar);
  200.                 AddResMenu(GetMHandle(mApple), 'DRVR');    /* add DA names to Apple menu */
  201.                 DrawMenuBar();
  202.  
  203.                 /* Get the yawn and wakeup sound resources. */
  204.                 wakeHndl = GetResource(soundListRsrc, 129);
  205.                 if (wakeHndl != nil)
  206.                 {
  207.                     DetachResource(wakeHndl);
  208.                     HLock(wakeHndl);
  209.                     yawnHndl = GetResource(soundListRsrc, 128);
  210.                     if (yawnHndl == nil)
  211.                     {
  212.                         HUnlock(wakeHndl);
  213.                         DisposHandle(wakeHndl);
  214.                         return false;
  215.                     }
  216.                     DetachResource(yawnHndl);
  217.                     HLock(yawnHndl);
  218.                 }
  219.                 else
  220.                 {
  221.                     return false;
  222.                 }
  223.                 
  224.                 /* tell the assembler routine about our sound handles */
  225.                 soundHandleSetup(yawnHndl, wakeHndl);
  226.  
  227.                 /* install our assembler routine in the sleep process queue */
  228.                 myRec.sleepQLink = 0;
  229.                 myRec.sleepQType = slpQType;
  230.                 myRec.sleepQProc = (ProcPtr) &soundasleep;
  231.                 myRec.sleepQFlags = 0;
  232.                 
  233.                 SleepQInstall(&myRec);
  234.                 return true;
  235.             }
  236.         }
  237.     }
  238.     
  239.     /*    If we get here, something is wrong so put up the About box which tells the user what
  240.         machine they can run on. Certainly the error reporting can be improved, so if it really
  241.         bothers you, feel free. */
  242.     (void) Alert(rAboutAlert, nil);
  243.     return false;
  244. } /*Initialize*/
  245.  
  246. #pragma segment Main
  247.  
  248. /*    This routine is called at both sleep and wakeup time to play the appropriate sound.
  249.     We want the wakeup sound to be asynchronous, but the beddie-bye sound to be synchronous,
  250.     so we do a stupid trick on a static Boolean variable to toggle the sync state each time
  251.     we're called since for every sleep there is a wake after it.
  252. */
  253.  
  254. pascal void
  255. playthatsound(soundHndl)
  256. Handle soundHndl;
  257. {
  258.     static Boolean async = true;
  259.     async = !async;
  260.     SndPlay(nil, soundHndl, async);
  261. }
  262.